home *** CD-ROM | disk | FTP | other *** search
/ Champak 40 / Vol 40.iso / games / ufo_comm.swf / scripts / DefineSprite_479 / frame_145 / DoAction.as
Encoding:
Text File  |  2007-04-25  |  42.4 KB  |  1,173 lines

  1. var ┬º\x01┬º = 449;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 449)
  6.    {
  7.       set("\x01",eval("\x01") + 292);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 613)
  12.    {
  13.       set("\x01",eval("\x01") + 261);
  14.       ┬º┬ºpush(true);
  15.       continue;
  16.    }
  17.    if(eval("\x01") == 636)
  18.    {
  19.       set("\x01",eval("\x01") - 507);
  20.       loop8:
  21.       while(true)
  22.       {
  23.          set(┬º┬ºpop(),eval(┬º┬ºpop()) - 155);
  24.          ┬º┬ºpush(true);
  25.          while(true)
  26.          {
  27.             if(eval("\x01") == 697)
  28.             {
  29.                set("\x01",eval("\x01") - 86);
  30.                ┬º┬ºpush(true);
  31.                continue;
  32.             }
  33.             if(eval("\x01") == 57)
  34.             {
  35.                set("\x01",eval("\x01") + 475);
  36.                if(┬º┬ºpop())
  37.                {
  38.                   set("\x01",eval("\x01") - 73);
  39.                }
  40.                continue;
  41.             }
  42.             if(eval("\x01") == 36)
  43.             {
  44.                set("\x01",eval("\x01") + 953);
  45.                prevFrame();
  46.                break loop0;
  47.             }
  48.             if(eval("\x01") == 611)
  49.             {
  50.                set("\x01",eval("\x01") + 162);
  51.                if(┬º┬ºpop())
  52.                {
  53.                   set("\x01",eval("\x01") - 213);
  54.                }
  55.                continue;
  56.             }
  57.             if(eval("\x01") == 752)
  58.             {
  59.                set("\x01",eval("\x01") + 149);
  60.                break loop0;
  61.             }
  62.             if(eval("\x01") == 989)
  63.             {
  64.                set("\x01",eval("\x01") - 760);
  65.                ┬º┬ºpush(true);
  66.                continue;
  67.             }
  68.             if(eval("\x01") == 665)
  69.             {
  70.                set("\x01",eval("\x01") + 87);
  71.                if(┬º┬ºpop())
  72.                {
  73.                   set("\x01",eval("\x01") + 149);
  74.                }
  75.                continue;
  76.             }
  77.             if(eval("\x01") == 560)
  78.             {
  79.                set("\x01",eval("\x01") + 105);
  80.                ┬º┬ºpush(true);
  81.                continue;
  82.             }
  83.             if(eval("\x01") == 471)
  84.             {
  85.                set("\x01",eval("\x01") - 414);
  86.                ┬º┬ºpush(true);
  87.                continue;
  88.             }
  89.             if(eval("\x01") == 723)
  90.             {
  91.                set("\x01",eval("\x01") - 292);
  92.                loop10:
  93.                while(true)
  94.                {
  95.                   set(┬º┬ºpop(),┬º┬ºpop() + ┬º┬ºpop());
  96.                   if(┬º┬ºpop())
  97.                   {
  98.                      set("\x01",eval("\x01") - 308);
  99.                   }
  100.                   addr360:
  101.                   while(true)
  102.                   {
  103.                      if(eval("\x01") == 488)
  104.                      {
  105.                         set("\x01",eval("\x01") - 387);
  106.                         ┬º┬ºpush(true);
  107.                         continue;
  108.                      }
  109.                      if(eval("\x01") == 365)
  110.                      {
  111.                         set("\x01",eval("\x01") + 116);
  112.                         toggleHighQuality();
  113.                         ┬º┬ºpop()[┬º┬ºpop()] = eval(┬º┬ºpop())[┬º┬ºconstant(16)][┬º┬ºconstant(12)];
  114.                         _root[┬º┬ºconstant(11)] = level[┬º┬ºconstant(16)][┬º┬ºconstant(11)] - 10;
  115.                         _root[┬º┬ºconstant(19)][┬º┬ºconstant(18)]();
  116.                         _root[┬º┬ºconstant(8)](┬º┬ºconstant(20));
  117.                         _root[┬º┬ºconstant(10)] = 0;
  118.                         _root[┬º┬ºconstant(11)] += _root[┬º┬ºconstant(10)];
  119.                         _root[┬º┬ºconstant(9)] = 100;
  120.                         if(_root[┬º┬ºconstant(11)] >= 500)
  121.                         {
  122.                            level[┬º┬ºconstant(23)]--;
  123.                            if(level[┬º┬ºconstant(24)] >= level[┬º┬ºconstant(25)])
  124.                            {
  125.                               level[┬º┬ºconstant(26)][┬º┬ºconstant(27)](2);
  126.                            }
  127.                            else if(level[┬º┬ºconstant(23)] == 0 && level[┬º┬ºconstant(24)] >= 1)
  128.                            {
  129.                               level[┬º┬ºconstant(26)][┬º┬ºconstant(27)](2);
  130.                            }
  131.                            else if(level[┬º┬ºconstant(23)] == 0)
  132.                            {
  133.                               level[┬º┬ºconstant(26)][┬º┬ºconstant(27)](┬º┬ºconstant(28));
  134.                            }
  135.                            removeMovieClip(_root);
  136.                         }
  137.                         break loop0;
  138.                      }
  139.                      if(eval("\x01") == 481)
  140.                      {
  141.                         set("\x01",eval("\x01") + 495);
  142.                         ┬º┬ºpush(true);
  143.                         continue;
  144.                      }
  145.                      if(eval("\x01") == 61)
  146.                      {
  147.                         set("\x01",eval("\x01") + 934);
  148.                         if(┬º┬ºpop())
  149.                         {
  150.                            set("\x01",eval("\x01") - 164);
  151.                         }
  152.                         continue;
  153.                      }
  154.                      if(eval("\x01") == 976)
  155.                      {
  156.                         set("\x01",eval("\x01") - 36);
  157.                         if(┬º┬ºpop())
  158.                         {
  159.                            set("\x01",eval("\x01") - 2);
  160.                         }
  161.                         continue;
  162.                      }
  163.                      if(eval("\x01") == 101)
  164.                      {
  165.                         break;
  166.                      }
  167.                      if(eval("\x01") == 659)
  168.                      {
  169.                         set("\x01",eval("\x01") - 289);
  170.                         this.swapDepths(100000 + _root.level);
  171.                         break loop0;
  172.                      }
  173.                      if(eval("\x01") == 823)
  174.                      {
  175.                         set("\x01",eval("\x01") - 258);
  176.                         if(┬º┬ºpop())
  177.                         {
  178.                            set("\x01",eval("\x01") + 332);
  179.                         }
  180.                         continue;
  181.                      }
  182.                      if(eval("\x01") != 456)
  183.                      {
  184.                         if(eval("\x01") == 995)
  185.                         {
  186.                            set("\x01",eval("\x01") - 164);
  187.                            break loop0;
  188.                         }
  189.                         if(eval("\x01") == 256)
  190.                         {
  191.                            set("\x01",eval("\x01") + 567);
  192.                            ┬º┬ºpush(true);
  193.                         }
  194.                         else if(eval("\x01") == 692)
  195.                         {
  196.                            set("\x01",eval("\x01") - 455);
  197.                            ┬º┬ºpush(true);
  198.                         }
  199.                         else
  200.                         {
  201.                            if(eval("\x01") == 137)
  202.                            {
  203.                               set("\x01",eval("\x01") + 319);
  204.                               break loop0;
  205.                            }
  206.                            if(eval("\x01") == 94)
  207.                            {
  208.                               set("\x01",eval("\x01") + 271);
  209.                               if(┬º┬ºpop())
  210.                               {
  211.                                  set("\x01",eval("\x01") + 116);
  212.                               }
  213.                            }
  214.                            else
  215.                            {
  216.                               if(eval("\x01") == 24)
  217.                               {
  218.                                  set("\x01",eval("\x01") + 668);
  219.                                  toggleHighQuality();
  220.                                  play();
  221.                                  ┬º┬ºpop()[┬º┬ºpop()][┬º┬ºconstant(7)]();
  222.                                  eval(┬º┬ºconstant(4))[┬º┬ºconstant(8)] = 80;
  223.                                  eval(┬º┬ºconstant(4))[┬º┬ºconstant(9)] = 0;
  224.                                  eval(┬º┬ºconstant(4))[┬º┬ºconstant(10)] = _root.go[┬º┬ºconstant(10)] + 58;
  225.                                  eval(┬º┬ºconstant(4))[┬º┬ºconstant(11)] = _root.go[┬º┬ºconstant(11)];
  226.                                  addr49:
  227.                                  if(eval(┬º┬ºconstant(4))[┬º┬ºconstant(10)] >= 500)
  228.                                  {
  229.                                     removeMovieClip(eval(┬º┬ºconstant(4)));
  230.                                  }
  231.                                  break loop0;
  232.                               }
  233.                               if(eval("\x01") == 396)
  234.                               {
  235.                                  set("\x01",eval("\x01") - 372);
  236.                                  if(┬º┬ºpop())
  237.                                  {
  238.                                     set("\x01",eval("\x01") + 668);
  239.                                  }
  240.                               }
  241.                               else
  242.                               {
  243.                                  if(eval("\x01") == 940)
  244.                                  {
  245.                                     set("\x01",eval("\x01") - 2);
  246.                                     break loop0;
  247.                                  }
  248.                                  if(eval("\x01") == 565)
  249.                                  {
  250.                                     break loop10;
  251.                                  }
  252.                                  if(eval("\x01") == 831)
  253.                                  {
  254.                                     set("\x01",eval("\x01") - 737);
  255.                                     ┬º┬ºpush(true);
  256.                                  }
  257.                                  else if(eval("\x01") == 710)
  258.                                  {
  259.                                     set("\x01",eval("\x01") - 507);
  260.                                     if(┬º┬ºpop())
  261.                                     {
  262.                                        set("\x01",eval("\x01") + 456);
  263.                                     }
  264.                                  }
  265.                                  else if(eval("\x01") == 897)
  266.                                  {
  267.                                     set("\x01",eval("\x01") - 501);
  268.                                     ┬º┬ºpush(true);
  269.                                  }
  270.                                  else if(eval("\x01") == 237)
  271.                                  {
  272.                                     set("\x01",eval("\x01") - 100);
  273.                                     if(┬º┬ºpop())
  274.                                     {
  275.                                        set("\x01",eval("\x01") + 319);
  276.                                     }
  277.                                  }
  278.                                  else
  279.                                  {
  280.                                     if(eval("\x01") == 564)
  281.                                     {
  282.                                        set("\x01",eval("\x01") - 308);
  283.                                        break loop0;
  284.                                     }
  285.                                     if(eval("\x01") != 938)
  286.                                     {
  287.                                        if(eval("\x01") == 203)
  288.                                        {
  289.                                           set("\x01",eval("\x01") + 456);
  290.                                           break loop0;
  291.                                        }
  292.                                        if(eval("\x01") == 370)
  293.                                        {
  294.                                           set("\x01",eval("\x01") - 370);
  295.                                        }
  296.                                        break loop0;
  297.                                     }
  298.                                     set("\x01",eval("\x01") - 228);
  299.                                     ┬º┬ºpush(true);
  300.                                  }
  301.                               }
  302.                            }
  303.                         }
  304.                         continue;
  305.                      }
  306.                      ┬º┬ºpush("\x01");
  307.                      ┬º┬ºpush(eval("\x01"));
  308.                      ┬º┬ºpush(395);
  309.                   }
  310.                }
  311.                set("\x01",eval("\x01") + 332);
  312.                break loop0;
  313.             }
  314.             if(eval("\x01") == 735)
  315.             {
  316.                set("\x01",eval("\x01") - 185);
  317.                ┬º┬ºpush(true);
  318.                continue;
  319.             }
  320.             if(eval("\x01") == 773)
  321.             {
  322.                set("\x01",eval("\x01") - 213);
  323.                break loop0;
  324.             }
  325.             if(eval("\x01") == 845)
  326.             {
  327.                set("\x01",eval("\x01") - 809);
  328.                if(┬º┬ºpop())
  329.                {
  330.                   set("\x01",eval("\x01") + 953);
  331.                }
  332.                continue;
  333.             }
  334.             if(eval("\x01") == 696)
  335.             {
  336.                set("\x01",eval("\x01") + 27);
  337.                if(┬º┬ºpop())
  338.                {
  339.                   set("\x01",eval("\x01") - 292);
  340.                }
  341.                continue;
  342.             }
  343.             if(eval("\x01") == 837)
  344.             {
  345.                set("\x01",eval("\x01") - 102);
  346.                break loop0;
  347.             }
  348.             if(eval("\x01") == 973)
  349.             {
  350.                set("\x01",eval("\x01") - 136);
  351.                if(┬º┬ºpop())
  352.                {
  353.                   set("\x01",eval("\x01") - 102);
  354.                }
  355.                continue;
  356.             }
  357.             if(eval("\x01") == 459)
  358.             {
  359.                break;
  360.             }
  361.             if(eval("\x01") == 901)
  362.             {
  363.                set("\x01",eval("\x01") - 56);
  364.                ┬º┬ºpush(true);
  365.                continue;
  366.             }
  367.             if(eval("\x01") == 28)
  368.             {
  369.                set("\x01",eval("\x01") + 631);
  370.                loop13:
  371.                while(true)
  372.                {
  373.                   if(┬º┬ºpop() == ┬º┬ºpop())
  374.                   {
  375.                      set("\x01",eval("\x01") - 636);
  376.                      if(┬º┬ºpop())
  377.                      {
  378.                         set("\x01",eval("\x01") + 350);
  379.                      }
  380.                      addr1028:
  381.                      while(true)
  382.                      {
  383.                         if(eval("\x01") == 301)
  384.                         {
  385.                            set("\x01",eval("\x01") - 139);
  386.                            ┬º┬ºpush(true);
  387.                            continue;
  388.                         }
  389.                         if(eval("\x01") == 749)
  390.                         {
  391.                            set("\x01",eval("\x01") - 461);
  392.                            ┬º┬ºpush(true);
  393.                            continue;
  394.                         }
  395.                         ┬º┬ºpush(eval("\x01"));
  396.                         ┬º┬ºpush(947);
  397.                         continue loop13;
  398.                      }
  399.                      addr1028:
  400.                   }
  401.                   else if(eval("\x01") == 470)
  402.                   {
  403.                      set("\x01",eval("\x01") + 483);
  404.                      if(┬º┬ºpop())
  405.                      {
  406.                         set("\x01",eval("\x01") - 300);
  407.                      }
  408.                      ┬º┬ºgoto(addr1028);
  409.                   }
  410.                   else if(eval("\x01") == 661)
  411.                   {
  412.                      set("\x01",eval("\x01") - 191);
  413.                      ┬º┬ºgoto(addr1028);
  414.                      ┬º┬ºpush(true);
  415.                   }
  416.                   else
  417.                   {
  418.                      if(eval("\x01") == 953)
  419.                      {
  420.                         set("\x01",eval("\x01") - 300);
  421.                         break loop0;
  422.                      }
  423.                      if(eval("\x01") == 653)
  424.                      {
  425.                         set("\x01",eval("\x01") - 460);
  426.                         ┬º┬ºgoto(addr1028);
  427.                         ┬º┬ºpush(true);
  428.                      }
  429.                      else if(eval("\x01") == 418)
  430.                      {
  431.                         set("\x01",eval("\x01") + 248);
  432.                         if(┬º┬ºpop())
  433.                         {
  434.                            set("\x01",eval("\x01") - 531);
  435.                         }
  436.                         ┬º┬ºgoto(addr1028);
  437.                      }
  438.                      else
  439.                      {
  440.                         if(eval("\x01") == 311)
  441.                         {
  442.                            set("\x01",eval("\x01") + 350);
  443.                            break loop0;
  444.                         }
  445.                         if(eval("\x01") == 821)
  446.                         {
  447.                            set("\x01",eval("\x01") - 64);
  448.                            ┬º┬ºgoto(addr1028);
  449.                            ┬º┬ºpush(true);
  450.                         }
  451.                         else
  452.                         {
  453.                            if(eval("\x01") == 524)
  454.                            {
  455.                               set("\x01",eval("\x01") + 93);
  456.                               ┬º┬ºpush(┬º┬ºpop()());
  457.                               break loop0;
  458.                            }
  459.                            if(eval("\x01") == 193)
  460.                            {
  461.                               set("\x01",eval("\x01") + 331);
  462.                               if(┬º┬ºpop())
  463.                               {
  464.                                  set("\x01",eval("\x01") + 93);
  465.                               }
  466.                               ┬º┬ºgoto(addr1028);
  467.                            }
  468.                            else if(eval("\x01") == 288)
  469.                            {
  470.                               set("\x01",eval("\x01") + 135);
  471.                               if(┬º┬ºpop())
  472.                               {
  473.                                  set("\x01",eval("\x01") + 159);
  474.                               }
  475.                               ┬º┬ºgoto(addr1028);
  476.                            }
  477.                            else if(eval("\x01") == 840)
  478.                            {
  479.                               set("\x01",eval("\x01") - 422);
  480.                               ┬º┬ºgoto(addr1028);
  481.                               ┬º┬ºpush(true);
  482.                            }
  483.                            else
  484.                            {
  485.                               if(eval("\x01") == 899)
  486.                               {
  487.                                  set("\x01",eval("\x01") - 150);
  488.                                  break loop0;
  489.                               }
  490.                               if(eval("\x01") == 135)
  491.                               {
  492.                                  addr1283:
  493.                                  set("\x01",eval("\x01") + 812);
  494.                                  ┬º┬ºpush(true);
  495.                                  while(true)
  496.                                  {
  497.                                     ┬º┬ºgoto(addr1028);
  498.                                     ┬º┬ºgoto(addr1283);
  499.                                  }
  500.                                  addr1293:
  501.                               }
  502.                               else if(eval("\x01") == 617)
  503.                               {
  504.                                  set("\x01",eval("\x01") - 587);
  505.                                  ┬º┬ºgoto(addr1028);
  506.                                  ┬º┬ºpush(true);
  507.                               }
  508.                               else if(eval("\x01") == 30)
  509.                               {
  510.                                  set("\x01",eval("\x01") + 869);
  511.                                  if(┬º┬ºpop())
  512.                                  {
  513.                                     set("\x01",eval("\x01") - 150);
  514.                                  }
  515.                                  ┬º┬ºgoto(addr1028);
  516.                               }
  517.                               else if(eval("\x01") != 423)
  518.                               {
  519.                                  if(eval("\x01") == 582)
  520.                                  {
  521.                                     set("\x01",eval("\x01") - 111);
  522.                                     stop();
  523.                                     break loop0;
  524.                                  }
  525.                                  if(eval("\x01") == 471)
  526.                                  {
  527.                                     set("\x01",eval("\x01") - 471);
  528.                                     break loop0;
  529.                                  }
  530.                                  if(eval("\x01") == 959)
  531.                                  {
  532.                                     set("\x01",eval("\x01") - 138);
  533.                                     break loop0;
  534.                                  }
  535.                                  if(eval("\x01") == 757)
  536.                                  {
  537.                                     set("\x01",eval("\x01") - 667);
  538.                                     if(┬º┬ºpop())
  539.                                     {
  540.                                        set("\x01",eval("\x01") + 750);
  541.                                     }
  542.                                  }
  543.                                  else
  544.                                  {
  545.                                     if(eval("\x01") == 90)
  546.                                     {
  547.                                        set("\x01",eval("\x01") + 750);
  548.                                        ┬º┬ºpush(getProperty(┬º┬ºpop(), _X));
  549.                                        break loop0;
  550.                                     }
  551.                                     if(eval("\x01") == 666)
  552.                                     {
  553.                                        set("\x01",eval("\x01") - 531);
  554.                                        break loop0;
  555.                                     }
  556.                                     if(eval("\x01") != 162)
  557.                                     {
  558.                                        break loop0;
  559.                                     }
  560.                                     set("\x01",eval("\x01") + 797);
  561.                                     if(┬º┬ºpop())
  562.                                     {
  563.                                        set("\x01",eval("\x01") - 138);
  564.                                     }
  565.                                  }
  566.                                  ┬º┬ºgoto(addr1028);
  567.                               }
  568.                               set("\x01",eval("\x01") + 159);
  569.                               while(true)
  570.                               {
  571.                                  set(┬º┬ºpop(),┬º┬ºpop() - 242);
  572.                                  do
  573.                                  {
  574.                                     while(true)
  575.                                     {
  576.                                        if(eval("\x01") == 526)
  577.                                        {
  578.                                           set("\x01",eval("\x01") - 63);
  579.                                           ┬º┬ºpush(true);
  580.                                           continue;
  581.                                        }
  582.                                        if(eval("\x01") != 360)
  583.                                        {
  584.                                           if(eval("\x01") == 463)
  585.                                           {
  586.                                              break;
  587.                                           }
  588.                                           if(eval("\x01") == 118)
  589.                                           {
  590.                                              set("\x01",eval("\x01") + 404);
  591.                                              ┬º┬ºpush(true);
  592.                                           }
  593.                                           else
  594.                                           {
  595.                                              if(eval("\x01") != 522)
  596.                                              {
  597.                                                 if(eval("\x01") == 107)
  598.                                                 {
  599.                                                    set("\x01",eval("\x01") + 565);
  600.                                                    break loop0;
  601.                                                 }
  602.                                                 if(eval("\x01") == 672)
  603.                                                 {
  604.                                                    set("\x01",eval("\x01") + 284);
  605.                                                    this.swapDepths(500);
  606.                                                    break loop0;
  607.                                                 }
  608.                                                 if(eval("\x01") == 956)
  609.                                                 {
  610.                                                    set("\x01",eval("\x01") - 956);
  611.                                                 }
  612.                                                 break loop0;
  613.                                              }
  614.                                              set("\x01",eval("\x01") - 415);
  615.                                              if(┬º┬ºpop())
  616.                                              {
  617.                                                 set("\x01",eval("\x01") + 565);
  618.                                              }
  619.                                           }
  620.                                           continue;
  621.                                        }
  622.                                        set("\x01",eval("\x01") - 242);
  623.                                        ┬º┬ºgoto(addr49);
  624.                                     }
  625.                                     set("\x01",eval("\x01") - 103);
  626.                                  }
  627.                                  while(!┬º┬ºpop());
  628.                                  
  629.                               }
  630.                            }
  631.                         }
  632.                      }
  633.                   }
  634.                   ┬º┬ºgoto(addr1283);
  635.                }
  636.             }
  637.             else
  638.             {
  639.                if(eval("\x01") == 431)
  640.                {
  641.                   break loop8;
  642.                }
  643.                if(eval("\x01") == 642)
  644.                {
  645.                   set("\x01",eval("\x01") - 171);
  646.                   stop();
  647.                   tellTarget("");
  648.                   while(true)
  649.                   {
  650.                      set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  651.                      ┬º┬ºgoto(addr360);
  652.                   }
  653.                   addr515:
  654.                }
  655.                else
  656.                {
  657.                   if(eval("\x01") == 659)
  658.                   {
  659.                      set("\x01",eval("\x01") + 37);
  660.                      ┬º┬ºpush(true);
  661.                      continue;
  662.                   }
  663.                   if(eval("\x01") == 390)
  664.                   {
  665.                      set("\x01",eval("\x01") + 583);
  666.                      ┬º┬ºpush(true);
  667.                      continue;
  668.                   }
  669.                   if(eval("\x01") != 532)
  670.                   {
  671.                      if(eval("\x01") == 304)
  672.                      {
  673.                         set("\x01",eval("\x01") - 276);
  674.                         if(┬º┬ºpop())
  675.                         {
  676.                            set("\x01",eval("\x01") + 631);
  677.                         }
  678.                      }
  679.                      else if(eval("\x01") == 550)
  680.                      {
  681.                         set("\x01",eval("\x01") + 92);
  682.                         if(┬º┬ºpop())
  683.                         {
  684.                            set("\x01",eval("\x01") - 171);
  685.                         }
  686.                      }
  687.                      else
  688.                      {
  689.                         if(eval("\x01") == 849)
  690.                         {
  691.                            set("\x01",eval("\x01") - 849);
  692.                            break loop0;
  693.                         }
  694.                         if(eval("\x01") == 229)
  695.                         {
  696.                            set("\x01",eval("\x01") + 154);
  697.                            if(┬º┬ºpop())
  698.                            {
  699.                               set("\x01",eval("\x01") - 235);
  700.                            }
  701.                         }
  702.                         else
  703.                         {
  704.                            if(eval("\x01") == 114)
  705.                            {
  706.                               set("\x01",eval("\x01") + 276);
  707.                               break loop0;
  708.                            }
  709.                            if(eval("\x01") == 383)
  710.                            {
  711.                               set("\x01",eval("\x01") - 235);
  712.                               if(eval("\x01") == 244)
  713.                               {
  714.                                  set("\x01",eval("\x01") + 412);
  715.                                  break loop0;
  716.                               }
  717.                               if(eval("\x01") == 53)
  718.                               {
  719.                                  set("\x01",eval("\x01") - 53);
  720.                               }
  721.                               break loop0;
  722.                            }
  723.                            if(eval("\x01") == 326)
  724.                            {
  725.                               set("\x01",eval("\x01") - 212);
  726.                               if(┬º┬ºpop())
  727.                               {
  728.                                  set("\x01",eval("\x01") + 276);
  729.                               }
  730.                            }
  731.                            else
  732.                            {
  733.                               if(eval("\x01") != 148)
  734.                               {
  735.                                  break loop0;
  736.                               }
  737.                               set("\x01",eval("\x01") + 178);
  738.                               ┬º┬ºpush(true);
  739.                            }
  740.                         }
  741.                      }
  742.                      continue;
  743.                   }
  744.                   set("\x01",eval("\x01") - 73);
  745.                   while(true)
  746.                   {
  747.                      if(┬º┬ºpop() == ┬º┬ºpop())
  748.                      {
  749.                         set("\x01",eval("\x01") + 184);
  750.                         ┬º┬ºpush(true);
  751.                      }
  752.                      else if(eval("\x01") == 889)
  753.                      {
  754.                         set("\x01",eval("\x01") - 773);
  755.                         ┬º┬ºpush(true);
  756.                      }
  757.                      else
  758.                      {
  759.                         if(eval("\x01") == 841)
  760.                         {
  761.                            set("\x01",eval("\x01") + 48);
  762.                            stop();
  763.                            ┬º┬ºpop();
  764.                            break loop0;
  765.                         }
  766.                         if(eval("\x01") == 643)
  767.                         {
  768.                            set("\x01",eval("\x01") + 91);
  769.                            stop();
  770.                            ┬º┬ºpop();
  771.                            break loop0;
  772.                         }
  773.                         if(eval("\x01") == 874)
  774.                         {
  775.                            set("\x01",eval("\x01") - 130);
  776.                            if(┬º┬ºpop())
  777.                            {
  778.                               set("\x01",eval("\x01") + 246);
  779.                            }
  780.                         }
  781.                         else if(eval("\x01") == 116)
  782.                         {
  783.                            set("\x01",eval("\x01") + 527);
  784.                            if(┬º┬ºpop())
  785.                            {
  786.                               set("\x01",eval("\x01") + 91);
  787.                            }
  788.                         }
  789.                         else if(eval("\x01") == 990)
  790.                         {
  791.                            set("\x01",eval("\x01") - 224);
  792.                            ┬º┬ºpush(true);
  793.                         }
  794.                         else
  795.                         {
  796.                            if(eval("\x01") == 744)
  797.                            {
  798.                               set("\x01",eval("\x01") + 246);
  799.                               break loop0;
  800.                            }
  801.                            if(eval("\x01") != 766)
  802.                            {
  803.                               if(eval("\x01") == 734)
  804.                               {
  805.                                  set("\x01",eval("\x01") - 525);
  806.                                  r = 1;
  807.                                  while(r <= 4)
  808.                                  {
  809.                                     removeMovieClip(_root["d" + r]);
  810.                                     r++;
  811.                                  }
  812.                                  _root.end = undefined;
  813.                                  stop();
  814.                                  break loop0;
  815.                               }
  816.                               if(eval("\x01") == 209)
  817.                               {
  818.                                  set("\x01",eval("\x01") - 209);
  819.                               }
  820.                               break loop0;
  821.                            }
  822.                            set("\x01",eval("\x01") + 75);
  823.                            if(┬º┬ºpop())
  824.                            {
  825.                               set("\x01",eval("\x01") + 48);
  826.                            }
  827.                         }
  828.                      }
  829.                   }
  830.                }
  831.             }
  832.             ┬º┬ºgoto(addr49);
  833.             ┬º┬ºgoto(addr515);
  834.          }
  835.       }
  836.       set("\x01",eval("\x01") + 418);
  837.       getUrl("http://www.onlinegameshq.com", "_blank");
  838.       break;
  839.    }
  840.    if(eval("\x01") == 167)
  841.    {
  842.       set("\x01",eval("\x01") + 500);
  843.       ┬º┬ºpush(true);
  844.       continue;
  845.    }
  846.    if(eval("\x01") != 81)
  847.    {
  848.       if(eval("\x01") == 667)
  849.       {
  850.          set("\x01",eval("\x01") - 122);
  851.          if(┬º┬ºpop())
  852.          {
  853.             set("\x01",eval("\x01") - 387);
  854.          }
  855.       }
  856.       else if(eval("\x01") == 129)
  857.       {
  858.          set("\x01",eval("\x01") + 334);
  859.          ┬º┬ºpush(true);
  860.       }
  861.       else
  862.       {
  863.          if(eval("\x01") == 767)
  864.          {
  865.             set("\x01",eval("\x01") - 3);
  866.             break;
  867.          }
  868.          if(eval("\x01") == 764)
  869.          {
  870.             set("\x01",eval("\x01") - 132);
  871.             ┬º┬ºpush(true);
  872.          }
  873.          else if(eval("\x01") == 292)
  874.          {
  875.             set("\x01",eval("\x01") - 11);
  876.             if(┬º┬ºpop())
  877.             {
  878.                set("\x01",eval("\x01") + 665);
  879.             }
  880.          }
  881.          else if(eval("\x01") == 741)
  882.          {
  883.             set("\x01",eval("\x01") - 660);
  884.             if(┬º┬ºpop())
  885.             {
  886.                set("\x01",eval("\x01") + 86);
  887.             }
  888.          }
  889.          else
  890.          {
  891.             if(eval("\x01") == 545)
  892.             {
  893.                set("\x01",eval("\x01") - 387);
  894.                ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  895.                break;
  896.             }
  897.             if(eval("\x01") == 389)
  898.             {
  899.                set("\x01",eval("\x01") + 414);
  900.                stop();
  901.                break;
  902.             }
  903.             if(eval("\x01") == 874)
  904.             {
  905.                set("\x01",eval("\x01") - 107);
  906.                if(┬º┬ºpop())
  907.                {
  908.                   set("\x01",eval("\x01") - 3);
  909.                }
  910.             }
  911.             else if(eval("\x01") == 158)
  912.             {
  913.                set("\x01",eval("\x01") + 134);
  914.                ┬º┬ºpush(true);
  915.             }
  916.             else
  917.             {
  918.                if(eval("\x01") == 281)
  919.                {
  920.                   set("\x01",eval("\x01") + 665);
  921.                   break;
  922.                }
  923.                if(eval("\x01") == 632)
  924.                {
  925.                   set("\x01",eval("\x01") + 84);
  926.                   if(┬º┬ºpop())
  927.                   {
  928.                      set("\x01",eval("\x01") + 5);
  929.                   }
  930.                }
  931.                else
  932.                {
  933.                   if(eval("\x01") == 716)
  934.                   {
  935.                      set("\x01",eval("\x01") + 5);
  936.                      break;
  937.                   }
  938.                   if(eval("\x01") == 462)
  939.                   {
  940.                      set("\x01",eval("\x01") + 151);
  941.                      ┬º┬ºenumerate(┬º┬ºpop());
  942.                      ┬º┬ºpush(┬º┬ºpop() >> ┬º┬ºenumeration());
  943.                      break;
  944.                   }
  945.                   if(eval("\x01") == 628)
  946.                   {
  947.                      set("\x01",eval("\x01") - 279);
  948.                      ┬º┬ºpush(true);
  949.                   }
  950.                   else if(eval("\x01") == 946)
  951.                   {
  952.                      set("\x01",eval("\x01") - 133);
  953.                      ┬º┬ºpush(true);
  954.                   }
  955.                   else
  956.                   {
  957.                      if(eval("\x01") == 966)
  958.                      {
  959.                         set("\x01",eval("\x01") - 577);
  960.                         return ┬º┬ºpop();
  961.                      }
  962.                      if(eval("\x01") == 463)
  963.                      {
  964.                         set("\x01",eval("\x01") + 503);
  965.                         if(┬º┬ºpop())
  966.                         {
  967.                            set("\x01",eval("\x01") - 577);
  968.                         }
  969.                      }
  970.                      else if(eval("\x01") == 323)
  971.                      {
  972.                         set("\x01",eval("\x01") + 313);
  973.                         if(┬º┬ºpop())
  974.                         {
  975.                            set("\x01",eval("\x01") - 507);
  976.                         }
  977.                      }
  978.                      else
  979.                      {
  980.                         if(eval("\x01") == 803)
  981.                         {
  982.                            set("\x01",eval("\x01") - 803);
  983.                            break;
  984.                         }
  985.                         if(eval("\x01") == 813)
  986.                         {
  987.                            set("\x01",eval("\x01") + 36);
  988.                            if(┬º┬ºpop())
  989.                            {
  990.                               set("\x01",eval("\x01") - 221);
  991.                            }
  992.                         }
  993.                         else
  994.                         {
  995.                            if(eval("\x01") == 849)
  996.                            {
  997.                               set("\x01",eval("\x01") - 221);
  998.                               ┬º┬ºpush(┬º┬ºpop()[┬º┬ºpop()]);
  999.                               break;
  1000.                            }
  1001.                            if(eval("\x01") == 349)
  1002.                            {
  1003.                               set("\x01",eval("\x01") + 113);
  1004.                               if(┬º┬ºpop())
  1005.                               {
  1006.                                  set("\x01",eval("\x01") + 151);
  1007.                               }
  1008.                            }
  1009.                            else
  1010.                            {
  1011.                               if(eval("\x01") != 721)
  1012.                               {
  1013.                                  break;
  1014.                               }
  1015.                               set("\x01",eval("\x01") - 398);
  1016.                               ┬º┬ºpush(true);
  1017.                            }
  1018.                         }
  1019.                      }
  1020.                   }
  1021.                }
  1022.             }
  1023.          }
  1024.       }
  1025.       continue;
  1026.    }
  1027.    set("\x01",eval("\x01") + 86);
  1028.    loop1:
  1029.    while(true)
  1030.    {
  1031.       if(┬º┬ºpop() == 395)
  1032.       {
  1033.          set("\x01",eval("\x01") + 581);
  1034.          ┬º┬ºpop();
  1035.          break loop0;
  1036.       }
  1037.       if(eval("\x01") == 256)
  1038.       {
  1039.          set("\x01",eval("\x01") + 147);
  1040.          ┬º┬ºpush(true);
  1041.       }
  1042.       else
  1043.       {
  1044.          if(eval("\x01") == 436)
  1045.          {
  1046.             set("\x01",eval("\x01") - 263);
  1047.             _root.go = "level" + _root.level;
  1048.             _root.gotoAndStop(_root.go);
  1049.             break loop0;
  1050.          }
  1051.          if(eval("\x01") == 860)
  1052.          {
  1053.             set("\x01",eval("\x01") - 642);
  1054.             break loop0;
  1055.          }
  1056.          if(eval("\x01") == 296)
  1057.          {
  1058.             set("\x01",eval("\x01") + 99);
  1059.             if(┬º┬ºpop())
  1060.             {
  1061.                set("\x01",eval("\x01") + 581);
  1062.             }
  1063.          }
  1064.          else if(eval("\x01") == 461)
  1065.          {
  1066.             set("\x01",eval("\x01") + 399);
  1067.             if(┬º┬ºpop())
  1068.             {
  1069.                set("\x01",eval("\x01") - 642);
  1070.             }
  1071.          }
  1072.          else if(eval("\x01") == 911)
  1073.          {
  1074.             set("\x01",eval("\x01") - 615);
  1075.             ┬º┬ºpush(true);
  1076.          }
  1077.          else if(eval("\x01") == 560)
  1078.          {
  1079.             set("\x01",eval("\x01") - 304);
  1080.             prevFrame();
  1081.             ┬º┬ºgoto(addr1293);
  1082.          }
  1083.          else if(eval("\x01") == 697)
  1084.          {
  1085.             set("\x01",eval("\x01") - 137);
  1086.             if(┬º┬ºpop())
  1087.             {
  1088.                set("\x01",eval("\x01") - 304);
  1089.             }
  1090.          }
  1091.          else
  1092.          {
  1093.             if(eval("\x01") != 403)
  1094.             {
  1095.                if(eval("\x01") == 497)
  1096.                {
  1097.                   set("\x01",eval("\x01") - 398);
  1098.                   break loop0;
  1099.                }
  1100.                if(eval("\x01") == 953)
  1101.                {
  1102.                   set("\x01",eval("\x01") - 517);
  1103.                   break loop0;
  1104.                }
  1105.                if(eval("\x01") == 173)
  1106.                {
  1107.                   set("\x01",eval("\x01") - 173);
  1108.                }
  1109.                break loop0;
  1110.             }
  1111.             set("\x01",eval("\x01") + 94);
  1112.             if(┬º┬ºpop())
  1113.             {
  1114.                set("\x01",eval("\x01") - 398);
  1115.             }
  1116.          }
  1117.       }
  1118.       while(true)
  1119.       {
  1120.          if(eval("\x01") == 96)
  1121.          {
  1122.             set("\x01",eval("\x01") + 365);
  1123.             ┬º┬ºpush(true);
  1124.             continue;
  1125.          }
  1126.          if(eval("\x01") == 518)
  1127.          {
  1128.             set("\x01",eval("\x01") - 197);
  1129.             if(┬º┬ºpop())
  1130.             {
  1131.                set("\x01",eval("\x01") + 590);
  1132.             }
  1133.             continue;
  1134.          }
  1135.          if(eval("\x01") == 321)
  1136.          {
  1137.             break;
  1138.          }
  1139.          if(eval("\x01") == 99)
  1140.          {
  1141.             set("\x01",eval("\x01") + 687);
  1142.             ┬º┬ºpush(true);
  1143.             continue;
  1144.          }
  1145.          if(eval("\x01") == 218)
  1146.          {
  1147.             set("\x01",eval("\x01") + 300);
  1148.             ┬º┬ºpush(true);
  1149.             continue;
  1150.          }
  1151.          if(eval("\x01") == 976)
  1152.          {
  1153.             set("\x01",eval("\x01") - 279);
  1154.             ┬º┬ºpush(true);
  1155.             continue;
  1156.          }
  1157.          if(eval("\x01") == 786)
  1158.          {
  1159.             set("\x01",eval("\x01") + 167);
  1160.             if(┬º┬ºpop())
  1161.             {
  1162.                set("\x01",eval("\x01") - 517);
  1163.             }
  1164.             continue;
  1165.          }
  1166.          continue loop1;
  1167.       }
  1168.       set("\x01",eval("\x01") + 590);
  1169.       break loop0;
  1170.    }
  1171.    ┬º┬ºgoto(addr1283);
  1172. }
  1173.